home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / posixfile.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  7KB  |  241 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. """Extended file operations available in POSIX.
  5.  
  6. f = posixfile.open(filename, [mode, [bufsize]])
  7.       will create a new posixfile object
  8.  
  9. f = posixfile.fileopen(fileobject)
  10.       will create a posixfile object from a builtin file object
  11.  
  12. f.file()
  13.       will return the original builtin file object
  14.  
  15. f.dup()
  16.       will return a new file object based on a new filedescriptor
  17.  
  18. f.dup2(fd)
  19.       will return a new file object based on the given filedescriptor
  20.  
  21. f.flags(mode)
  22.       will turn on the associated flag (merge)
  23.       mode can contain the following characters:
  24.  
  25.   (character representing a flag)
  26.       a       append only flag
  27.       c       close on exec flag
  28.       n       no delay flag
  29.       s       synchronization flag
  30.   (modifiers)
  31.       !       turn flags 'off' instead of default 'on'
  32.       =       copy flags 'as is' instead of default 'merge'
  33.       ?       return a string in which the characters represent the flags
  34.               that are set
  35.  
  36.       note: - the '!' and '=' modifiers are mutually exclusive.
  37.             - the '?' modifier will return the status of the flags after they
  38.               have been changed by other characters in the mode string
  39.  
  40. f.lock(mode [, len [, start [, whence]]])
  41.       will (un)lock a region
  42.       mode can contain the following characters:
  43.  
  44.   (character representing type of lock)
  45.       u       unlock
  46.       r       read lock
  47.       w       write lock
  48.   (modifiers)
  49.       |       wait until the lock can be granted
  50.       ?       return the first lock conflicting with the requested lock
  51.               or 'None' if there is no conflict. The lock returned is in the
  52.               format (mode, len, start, whence, pid) where mode is a
  53.               character representing the type of lock ('r' or 'w')
  54.  
  55.       note: - the '?' modifier prevents a region from being locked; it is
  56.               query only
  57. """
  58. import warnings
  59. warnings.warn('The posixfile module is obsolete and will disappear in the future', DeprecationWarning)
  60. del warnings
  61.  
  62. class _posixfile_:
  63.     '''File wrapper class that provides extra POSIX file routines.'''
  64.     states = [
  65.         'open',
  66.         'closed']
  67.     
  68.     def __repr__(self):
  69.         file = self._file_
  70.         return "<%s posixfile '%s', mode '%s' at %s>" % (self.states[file.closed], file.name, file.mode, hex(id(self))[2:])
  71.  
  72.     
  73.     def open(self, name, mode = 'r', bufsize = -1):
  74.         import __builtin__ as __builtin__
  75.         return self.fileopen(__builtin__.open(name, mode, bufsize))
  76.  
  77.     
  78.     def fileopen(self, file):
  79.         import types as types
  80.         if repr(type(file)) != "<type 'file'>":
  81.             raise TypeError, 'posixfile.fileopen() arg must be file object'
  82.         
  83.         self._file_ = file
  84.         for maybemethod in dir(file):
  85.             if not maybemethod.startswith('_'):
  86.                 attr = getattr(file, maybemethod)
  87.                 if isinstance(attr, types.BuiltinMethodType):
  88.                     setattr(self, maybemethod, attr)
  89.                 
  90.             isinstance(attr, types.BuiltinMethodType)
  91.         
  92.         return self
  93.  
  94.     
  95.     def file(self):
  96.         return self._file_
  97.  
  98.     
  99.     def dup(self):
  100.         import posix as posix
  101.         if not hasattr(posix, 'fdopen'):
  102.             raise AttributeError, 'dup() method unavailable'
  103.         
  104.         return posix.fdopen(posix.dup(self._file_.fileno()), self._file_.mode)
  105.  
  106.     
  107.     def dup2(self, fd):
  108.         import posix
  109.         if not hasattr(posix, 'fdopen'):
  110.             raise AttributeError, 'dup() method unavailable'
  111.         
  112.         posix.dup2(self._file_.fileno(), fd)
  113.         return posix.fdopen(fd, self._file_.mode)
  114.  
  115.     
  116.     def flags(self, *which):
  117.         import fcntl as fcntl
  118.         import os as os
  119.         if which:
  120.             if len(which) > 1:
  121.                 raise TypeError, 'Too many arguments'
  122.             
  123.             which = which[0]
  124.         else:
  125.             which = '?'
  126.         l_flags = 0
  127.         if 'n' in which:
  128.             l_flags = l_flags | os.O_NDELAY
  129.         
  130.         if 'a' in which:
  131.             l_flags = l_flags | os.O_APPEND
  132.         
  133.         if 's' in which:
  134.             l_flags = l_flags | os.O_SYNC
  135.         
  136.         file = self._file_
  137.         if '=' not in which:
  138.             cur_fl = fcntl.fcntl(file.fileno(), fcntl.F_GETFL, 0)
  139.             if '!' in which:
  140.                 l_flags = cur_fl & ~l_flags
  141.             else:
  142.                 l_flags = cur_fl | l_flags
  143.         
  144.         l_flags = fcntl.fcntl(file.fileno(), fcntl.F_SETFL, l_flags)
  145.         if 'c' in which:
  146.             arg = '!' not in which
  147.             l_flags = fcntl.fcntl(file.fileno(), fcntl.F_SETFD, arg)
  148.         
  149.         if '?' in which:
  150.             which = ''
  151.             l_flags = fcntl.fcntl(file.fileno(), fcntl.F_GETFL, 0)
  152.             if os.O_APPEND & l_flags:
  153.                 which = which + 'a'
  154.             
  155.             if fcntl.fcntl(file.fileno(), fcntl.F_GETFD, 0) & 1:
  156.                 which = which + 'c'
  157.             
  158.             if os.O_NDELAY & l_flags:
  159.                 which = which + 'n'
  160.             
  161.             if os.O_SYNC & l_flags:
  162.                 which = which + 's'
  163.             
  164.             return which
  165.         
  166.  
  167.     
  168.     def lock(self, how, *args):
  169.         import struct as struct
  170.         import fcntl
  171.         if 'w' in how:
  172.             l_type = fcntl.F_WRLCK
  173.         elif 'r' in how:
  174.             l_type = fcntl.F_RDLCK
  175.         elif 'u' in how:
  176.             l_type = fcntl.F_UNLCK
  177.         else:
  178.             raise TypeError, 'no type of lock specified'
  179.         if '|' in how:
  180.             cmd = fcntl.F_SETLKW
  181.         elif '?' in how:
  182.             cmd = fcntl.F_GETLK
  183.         else:
  184.             cmd = fcntl.F_SETLK
  185.         l_whence = 0
  186.         l_start = 0
  187.         l_len = 0
  188.         if len(args) == 1:
  189.             l_len = args[0]
  190.         elif len(args) == 2:
  191.             (l_len, l_start) = args
  192.         elif len(args) == 3:
  193.             (l_len, l_start, l_whence) = args
  194.         elif len(args) > 3:
  195.             raise TypeError, 'too many arguments'
  196.         
  197.         import sys as sys
  198.         import os
  199.         if sys.platform in ('netbsd1', 'openbsd2', 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5', 'freebsd6', 'bsdos2', 'bsdos3', 'bsdos4'):
  200.             flock = struct.pack('lxxxxlxxxxlhh', l_start, l_len, os.getpid(), l_type, l_whence)
  201.         elif sys.platform in [
  202.             'aix3',
  203.             'aix4']:
  204.             flock = struct.pack('hhlllii', l_type, l_whence, l_start, l_len, 0, 0, 0)
  205.         else:
  206.             flock = struct.pack('hhllhh', l_type, l_whence, l_start, l_len, 0, 0)
  207.         flock = fcntl.fcntl(self._file_.fileno(), cmd, flock)
  208.         if '?' in how:
  209.             if sys.platform in ('netbsd1', 'openbsd2', 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5', 'bsdos2', 'bsdos3', 'bsdos4'):
  210.                 (l_start, l_len, l_pid, l_type, l_whence) = struct.unpack('lxxxxlxxxxlhh', flock)
  211.             elif sys.platform in [
  212.                 'aix3',
  213.                 'aix4']:
  214.                 (l_type, l_whence, l_start, l_len, l_sysid, l_pid, l_vfs) = struct.unpack('hhlllii', flock)
  215.             elif sys.platform == 'linux2':
  216.                 (l_type, l_whence, l_start, l_len, l_pid, l_sysid) = struct.unpack('hhllhh', flock)
  217.             else:
  218.                 (l_type, l_whence, l_start, l_len, l_sysid, l_pid) = struct.unpack('hhllhh', flock)
  219.             if l_type != fcntl.F_UNLCK:
  220.                 if l_type == fcntl.F_RDLCK:
  221.                     return ('r', l_len, l_start, l_whence, l_pid)
  222.                 else:
  223.                     return ('w', l_len, l_start, l_whence, l_pid)
  224.             
  225.         
  226.  
  227.  
  228.  
  229. def open(name, mode = 'r', bufsize = -1):
  230.     '''Public routine to open a file as a posixfile object.'''
  231.     return _posixfile_().open(name, mode, bufsize)
  232.  
  233.  
  234. def fileopen(file):
  235.     '''Public routine to get a posixfile object from a Python file object.'''
  236.     return _posixfile_().fileopen(file)
  237.  
  238. SEEK_SET = 0
  239. SEEK_CUR = 1
  240. SEEK_END = 2
  241.